﻿using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using GBT.ManageEnties;
using GBT.ParamEntity;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using NLog;
using PersistenceDataLogic.Core;
using QueryDataLogic.Core;

namespace WebAPI_QiSiMealSystem.Controllers
{
    [Route("gbt/[controller]")]
    [ApiController]
    public class BasicInfoController : ControllerBase
    {
        private static Logger logger = LogManager.GetCurrentClassLogger();
        BasicInfo bi = new BasicInfo();
        OperationBasic ob = new OperationBasic();
        DishesManage d = new DishesManage();

        // GET: api/BasicInfo
        [HttpGet]
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET: gbt/BasicInfo/DiningHall/5
        [HttpGet("DiningHall/{districtID}", Name = "GetDiningHall")]
        public async Task<IActionResult> GetDiningHall(int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDiningHall(districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/DiningHallInfo
        [HttpPost("DiningHallInfo")]
        public async Task<IActionResult> GetDiningHallInfo(System_DiningHall diningHall)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<System_DiningHall> diningHalls = new List<System_DiningHall>();
                try
                {
                    diningHalls = bi.GetDiningHallInfo(diningHall, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = diningHalls, totalNumber, totalPage });
            });
            return task;
        }

        // GET: gbt/BasicInfo/Meal/5
        [HttpGet("Meal/{districtID}", Name = "GetMeal")]
        public async Task<IActionResult> GetMeal(int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetMeal(districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/MealTimeInfo
        [HttpPost("MealTimeInfo")]
        public async Task<IActionResult> GetMealTimeInfo(System_MealTime mealTime)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<System_MealTime> mealTimes = new List<System_MealTime>();
                try
                {
                    mealTimes = bi.GetMealTimeInfo(mealTime, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = mealTimes, totalNumber, totalPage });
            });
            return task;
        }

        // GET: gbt/BasicInfo/MealList/5
        [HttpGet("MealList/{districtID}", Name = "GetMealList")]
        public async Task<IActionResult> GetMealList(int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetMealList(districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/AddressBook
        [HttpGet("AddressBook/{CurrentPage}/{districtID}", Name = "GetAddressBook")]
        public async Task<IActionResult> GetAddressBook(int CurrentPage,int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetAddressBook(CurrentPage, districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/AddressBookInfo
        [HttpPost("AddressBookInfo")]
        public async Task<IActionResult> GetAddressBookInfo(System_AddressBook addressBook)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<System_AddressBook> mealTimes = new List<System_AddressBook>();
                try
                {
                    mealTimes = bi.GetAddressBookInfo(addressBook, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = mealTimes, totalNumber, totalPage });
            });
            return task;
        }

        // GET: gbt/BasicInfo/Evaluation
        [HttpGet("Evaluation/{CurrentPage}/{districtID}", Name = "GetEvaluation")]
        public async Task<IActionResult> GetEvaluation(int CurrentPage, int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetEvaluation(CurrentPage, districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/EvaluationContentInfo
        [HttpPost("EvaluationContentInfo")]
        public async Task<IActionResult> GetEvaluationContentInfo(System_EvaluationContent evaluationContent)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<System_EvaluationContent> mealTimes = new List<System_EvaluationContent>();
                try
                {
                    mealTimes = bi.GetEvaluationInfo(evaluationContent, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = mealTimes, totalNumber, totalPage });
            });
            return task;
        }

        // GET: gbt/BasicInfo/District
        [HttpGet("District/{CurrentPage}/{name}", Name = "GetDistrict")]
        public async Task<IActionResult> GetDistrict(int CurrentPage, string name)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    if (name == "empty")
                    {
                        name = "";
                    }
                    joResult = bi.GetDistrict(CurrentPage, name);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DistrictInfo
        [HttpGet("DistrictInfo/{id}", Name = "DistrictInfo")]
        public async Task<IActionResult> GetDistrictInfo(int id)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDistrictInfo(id);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/DistrictList
        [HttpPost("DistrictList")]
        public async Task<IActionResult> GetDistrictList(Manage_District manage_District)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<Manage_District> manage_Districts = new List<Manage_District>();
                try
                {
                    manage_Districts = bi.GetDistrictList(manage_District, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = manage_Districts, totalNumber, totalPage, Error });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DistrictInfoCurr
        [HttpGet("DistrictInfoCurr/{id}", Name = "DistrictInfoCurr")]
        public async Task<IActionResult> GetDistrictInfoCurr(int id)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDistrictCurrent(id);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DistrictInfoCurrent
        [HttpGet("DistrictInfoCurrent/{CurrentPage}/{id}", Name = "DistrictInfoCurrent")]
        public async Task<IActionResult> GetDistrictInfoCurrent(int CurrentPage,int id)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDistrictCurrent(CurrentPage, id);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/Company
        [HttpGet("Company/{CurrentPage}/{name}", Name = "GetCompany")]
        public async Task<IActionResult> GetCompany(int CurrentPage, string name)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    if (name == "empty")
                    {
                        name = "";
                    }
                    joResult = bi.GetCompany(CurrentPage, name);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/CompanyList
        [HttpPost("CompanyList")]
        public async Task<IActionResult> GetCompanyList(Manage_Company manage_Company)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<Manage_Company> manage_Companies = new List<Manage_Company>();
                try
                {
                    manage_Companies = bi.GetCompanyList(manage_Company, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = manage_Companies, totalNumber, totalPage, Error });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DishesClass
        [HttpGet("DishesClass/{CurrentPage}/{districtID}", Name = "GetDishesClass")]
        public async Task<IActionResult> GetDishesClass(int CurrentPage, int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDishesClass(CurrentPage, districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/DishesClassInfo
        [HttpPost("DishesClassInfo")]
        public async Task<IActionResult> GetDishesClassInfo(System_DishesClass dishesClass)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<System_DishesClass> dishesClasses = new List<System_DishesClass>();
                try
                {
                    dishesClasses = bi.GetDishesClassInfo(dishesClass, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = dishesClasses, totalNumber, totalPage });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DishesClassPicker
        [HttpGet("DishesClassPicker/{hallID}/{districtID}", Name = "GetDishesClassPicker")]
        public async Task<IActionResult> GetDishesClassPicker(int hallID, int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDishesClassPicker(hallID, districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/AttributePicker
        [HttpGet("AttributePicker/{hallID}/{districtID}", Name = "GetAttributePicker")]
        public async Task<IActionResult> GetAttributePicker(int hallID, int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetAttributePicker(hallID, districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DishesSet
        [HttpPost("DishesSet")]
        public async Task<IActionResult> GetDishesSet([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDishesSet(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/Dishes
        [HttpPost("Dishes")]
        public async Task<IActionResult> GetDishes([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = d.GetDishes(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/Attribute
        [HttpGet("Attribute/{CurrentPage}/{districtID}", Name = "GetAttribute")]
        public async Task<IActionResult> GetAttribute(int CurrentPage, int districtID)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetAttribute(CurrentPage, districtID);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/AttributeInfo
        [HttpPost("AttributeInfo")]
        public async Task<IActionResult> GetAttributeInfo(System_Attribute attribute)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                int totalNumber = 0;
                int totalPage = 0;
                string Error = "";
                List<System_Attribute> attributes = new List<System_Attribute>();
                try
                {
                    attributes = bi.GetAttributeInfo(attribute, ref totalNumber, ref totalPage);
                }
                catch (Exception ex)
                {
                    Error = ex.Message + Environment.NewLine + ex.StackTrace;
                    logger.Error(ex);
                }
                return Ok(new { data = attributes, totalNumber, totalPage });
            });
            return task;
        }

        // GET: gbt/BasicInfo/DishesDetail
        [HttpGet("DishesDetail/{districtID}/{id}", Name = "GetDishesDetail")]
        public async Task<IActionResult> GetDishesDetail(int districtID, int id)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = bi.GetDishesDetail(districtID, id);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // GET: gbt/BasicInfo/GetVersionInfo
        [HttpGet("GetVersionInfo", Name = "GetVersionInfo")]
        public async Task<IActionResult> GetVersionInfo()
        {
            OkObjectResult task = await Task.Run(() =>
            {
                List<Versions> versions = new List<Versions>();
                try
                {
                    versions = bi.GetVersionInfo();
                }
                catch (Exception ex)
                {
                    logger.Error(ex);
                }
                return Ok(new { root = versions });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptDiningHall
        [HttpPost("OptDiningHall")]
        public async Task<IActionResult> PostOptDiningHall([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptDiningHall(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptMealTime
        [HttpPost("OptMealTime")]
        public async Task<IActionResult> PostOptMealTime([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptMealTime(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptAddressBook
        [HttpPost("OptAddressBook")]
        public async Task<IActionResult> PostOptAddressBook([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptAddressBook(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptEvaluation
        [HttpPost("OptEvaluation")]
        public async Task<IActionResult> PostOptEvaluation([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptEvaluation(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/DisableEvaluation
        [HttpPost("DisableEvaluation")]
        public async Task<IActionResult> PostDisableEvaluation([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.DisableEvaluation(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptDistrict
        [HttpPost("OptDistrict")]
        public async Task<IActionResult> PostOptDistrict([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptDistrict(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptDistrictCurrent
        [HttpPost("OptDistrictCurrent")]
        public async Task<IActionResult> PostOptDistrictCurrent([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptDistrictCurrent(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptCompany
        [HttpPost("OptCompany")]
        public async Task<IActionResult> PostOptCompany([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptCompany(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptDishesClass
        [HttpPost("OptDishesClass")]
        public async Task<IActionResult> PostOptDishesClass([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptDishesClass(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptDishes
        [HttpPost("OptDishes")]
        public async Task<IActionResult> PostOptDishes([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptDishes(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // POST: gbt/BasicInfo/OptAttribute
        [HttpPost("OptAttribute")]
        public async Task<IActionResult> PostOptAttribute([FromBody] JObject value)
        {
            OkObjectResult task = await Task.Run(() =>
            {
                JObject joResult = new JObject
                {
                    ["Error"] = ""
                };
                try
                {
                    joResult = ob.OptAttribute(value);
                }
                catch (Exception ex)
                {
                    joResult["Error"] = ex.Message + "\r\n" + ex.StackTrace;
                }
                return Ok(new { root = joResult });
            });
            return task;
        }

        // PUT: gbt/BasicInfo/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] string value)
        {
        }

        // DELETE: gbt/ApiWithActions/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
    }
}
